home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / java / io / ObjectInputStream.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  11.4 KB  |  762 lines
  1. package java.io;
  2.  
  3. import java.util.Vector;
  4.  
  5. public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants {
  6.    // $FF: renamed from: in java.io.InputStream
  7.    private InputStream field_0;
  8.    private int count;
  9.    private boolean blockDataMode;
  10.    private byte[] buffer;
  11.    private DataInputStream dis;
  12.    private IOException abortIOException;
  13.    private ClassNotFoundException abortClassNotFoundException;
  14.    private Object currentObject;
  15.    private ObjectStreamClass currentClassDesc;
  16.    private Class currentClass;
  17.    ObjectStreamClass[] classdesc;
  18.    Class[] classes;
  19.    int spClass;
  20.    private Vector wireHandle2Object;
  21.    private int nextWireOffset;
  22.    private Vector callbacks;
  23.    private int recursionDepth;
  24.    private byte currCode;
  25.    private boolean enableResolve;
  26.  
  27.    public ObjectInputStream(InputStream var1) throws IOException, StreamCorruptedException {
  28.       this.field_0 = var1;
  29.       this.dis = new DataInputStream(this);
  30.       this.readStreamHeader();
  31.       this.resetStream();
  32.    }
  33.  
  34.    public final Object readObject() throws OptionalDataException, ClassNotFoundException, IOException {
  35.       int var1;
  36.       if (this.blockDataMode && (var1 = this.available()) > 0) {
  37.          throw new OptionalDataException(var1);
  38.       } else {
  39.          this.peekCode();
  40.          Object var2 = this.currentObject;
  41.          ObjectStreamClass var3 = this.currentClassDesc;
  42.          boolean var4 = this.setBlockData(false);
  43.          ++this.recursionDepth;
  44.          Object var5 = null;
  45.          byte var6 = this.readCode();
  46.  
  47.          try {
  48.             int var9 = -1;
  49.             switch (var6) {
  50.                case 112:
  51.                   var5 = null;
  52.                   break;
  53.                case 113:
  54.                   var9 = this.readInt() - 8257536;
  55.  
  56.                   try {
  57.                      var5 = this.wireHandle2Object.elementAt(var9);
  58.                      break;
  59.                   } catch (ArrayIndexOutOfBoundsException var20) {
  60.                      throw new StreamCorruptedException("Reference to object never serialized.");
  61.                   }
  62.                case 114:
  63.                   var5 = this.inputClassDescriptor();
  64.                   break;
  65.                case 115:
  66.                   var9 = this.inputObject();
  67.                   var5 = this.currentObject;
  68.                   if (this.enableResolve) {
  69.                      var5 = this.resolveObject(var5);
  70.                      this.wireHandle2Object.setElementAt(var5, var9);
  71.                   }
  72.                   break;
  73.                case 116:
  74.                   var5 = this.readUTF();
  75.                   this.assignWireOffset(var5);
  76.                   break;
  77.                case 117:
  78.                   var5 = this.inputArray();
  79.                   break;
  80.                case 118:
  81.                   ObjectStreamClass var10 = (ObjectStreamClass)this.readObject();
  82.                   if (var10 == null) {
  83.                      throw new StreamCorruptedException("Class not in stream");
  84.                   }
  85.  
  86.                   var5 = var10.forClass();
  87.                   this.assignWireOffset(var5);
  88.                   break;
  89.                case 119:
  90.                case 122:
  91.                   if (var6 == 122) {
  92.                      int var27 = this.field_0.read();
  93.                      int var12 = this.field_0.read();
  94.                      int var13 = this.field_0.read();
  95.                      int var14 = this.field_0.read();
  96.                      if ((var27 | var12 | var13 | var14) < 0) {
  97.                         throw new StreamCorruptedException("EOF expecting count");
  98.                      }
  99.  
  100.                      this.count = var27 << 24 | var12 << 16 | var13 << 8 | var14;
  101.                      if (this.count < 0) {
  102.                         throw new StreamCorruptedException("Negative block data size");
  103.                      }
  104.                   } else {
  105.                      this.count = this.field_0.read();
  106.                      if (this.count < 0) {
  107.                         throw new StreamCorruptedException("EOF expecting count");
  108.                      }
  109.                   }
  110.  
  111.                   if (!var4) {
  112.                      throw new StreamCorruptedException("Unexpected blockdata");
  113.                   }
  114.  
  115.                   throw new OptionalDataException(this.count);
  116.                case 120:
  117.                   if (!var4) {
  118.                      throw new StreamCorruptedException("Unexpected end of block data");
  119.                   }
  120.  
  121.                   this.pushbackCode((byte)120);
  122.                   this.count = -1;
  123.                   throw new OptionalDataException(true);
  124.                case 121:
  125.                default:
  126.                   throw new StreamCorruptedException("Unknown code in readObject " + var6);
  127.                case 123:
  128.                   this.resetStream();
  129.                   IOException var11 = (IOException)this.readObject();
  130.                   this.resetStream();
  131.                   throw new WriteAbortedException("Writing aborted by exception", var11);
  132.             }
  133.          } catch (OptionalDataException var21) {
  134.             throw var21;
  135.          } catch (IOException var22) {
  136.             if (this.abortIOException == null && this.abortClassNotFoundException == null) {
  137.                this.abortIOException = var22;
  138.             }
  139.          } catch (ClassNotFoundException var23) {
  140.             if (this.abortIOException == null && this.abortClassNotFoundException == null) {
  141.                this.abortClassNotFoundException = var23;
  142.             }
  143.          } finally {
  144.             --this.recursionDepth;
  145.             this.currentObject = var2;
  146.             this.currentClassDesc = var3;
  147.             this.setBlockData(var4);
  148.          }
  149.  
  150.          IOException var7 = this.abortIOException;
  151.          if (this.recursionDepth == 0) {
  152.             this.abortIOException = null;
  153.          }
  154.  
  155.          if (var7 != null) {
  156.             throw var7;
  157.          } else {
  158.             ClassNotFoundException var8 = this.abortClassNotFoundException;
  159.             if (this.recursionDepth == 0) {
  160.                this.abortClassNotFoundException = null;
  161.             }
  162.  
  163.             if (var8 != null) {
  164.                throw var8;
  165.             } else {
  166.                if (this.recursionDepth == 0) {
  167.                   this.doValidations();
  168.                }
  169.  
  170.                return var5;
  171.             }
  172.          }
  173.       }
  174.    }
  175.  
  176.    public final void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException {
  177.       if (this.currentObject != null && this.currentClassDesc != null) {
  178.          if (this.currentClassDesc.getFieldSequence() != null) {
  179.             boolean var1 = this.setBlockData(false);
  180.             this.inputClassFields(this.currentObject, this.currentClass, this.currentClassDesc.getFieldSequence());
  181.             this.setBlockData(var1);
  182.          }
  183.  
  184.       } else {
  185.          throw new NotActiveException("defaultReadObject");
  186.       }
  187.    }
  188.  
  189.    public synchronized void registerValidation(ObjectInputValidation var1, int var2) throws NotActiveException, InvalidObjectException {
  190.       if (this.recursionDepth == 0) {
  191.          throw new NotActiveException("readObject not Active");
  192.       } else if (var1 == null) {
  193.          throw new InvalidObjectException("Null is not a valid callback object");
  194.       } else {
  195.          ValidationCallback var3 = new ValidationCallback(var1, var2);
  196.          if (this.callbacks == null) {
  197.             this.callbacks = new Vector(100, 100);
  198.          }
  199.  
  200.          if (!this.callbacks.isEmpty() && ((ValidationCallback)this.callbacks.lastElement()).priority < var2) {
  201.             int var4 = this.callbacks.size();
  202.  
  203.             for(int var5 = 0; var5 < var4; ++var5) {
  204.                ValidationCallback var6 = (ValidationCallback)this.callbacks.elementAt(var5);
  205.                if (var6.priority <= var2) {
  206.                   this.callbacks.insertElementAt(var3, var5);
  207.                   return;
  208.                }
  209.             }
  210.  
  211.          } else {
  212.             this.callbacks.addElement(var3);
  213.          }
  214.       }
  215.    }
  216.  
  217.    private void doValidations() throws InvalidObjectException {
  218.       if (this.callbacks != null) {
  219.          int var1 = this.callbacks.size();
  220.  
  221.          for(int var2 = 0; var2 < var1; ++var2) {
  222.             ValidationCallback var3 = (ValidationCallback)this.callbacks.elementAt(var2);
  223.             var3.callback.validateObject();
  224.          }
  225.  
  226.       }
  227.    }
  228.  
  229.    protected Class resolveClass(ObjectStreamClass var1) throws IOException, ClassNotFoundException {
  230.       return this.loadClass0((Class)null, var1.getName());
  231.    }
  232.  
  233.    private native Class loadClass0(Class var1, String var2) throws ClassNotFoundException;
  234.  
  235.    protected Object resolveObject(Object var1) throws IOException {
  236.       return var1;
  237.    }
  238.  
  239.    protected final boolean enableResolveObject(boolean var1) throws SecurityException {
  240.       boolean var2 = this.enableResolve;
  241.       if (var1) {
  242.          ClassLoader var3 = this.getClass().getClassLoader();
  243.          if (var3 == null) {
  244.             this.enableResolve = true;
  245.             return var2;
  246.          } else {
  247.             throw new SecurityException("Not trusted class");
  248.          }
  249.       } else {
  250.          this.enableResolve = false;
  251.          return var2;
  252.       }
  253.    }
  254.  
  255.    protected void readStreamHeader() throws IOException, StreamCorruptedException {
  256.       short var1 = this.readShort();
  257.       short var2 = this.readShort();
  258.       if (var1 != -21267) {
  259.          throw new StreamCorruptedException("InputStream does not contain a serialized object");
  260.       } else if (var2 != 5) {
  261.          throw new StreamCorruptedException("Version Mismatch, Expected " + 5 + " and got " + var2);
  262.       }
  263.    }
  264.  
  265.    private ObjectStreamClass inputClassDescriptor() throws IOException, InvalidClassException, ClassNotFoundException {
  266.       String var2 = this.readUTF();
  267.       long var3 = this.readLong();
  268.       ObjectStreamClass var5 = new ObjectStreamClass(var2, var3);
  269.       this.assignWireOffset(var5);
  270.       var5.read(this);
  271.       boolean var6 = this.setBlockData(true);
  272.       Class var1 = this.resolveClass(var5);
  273.       this.SkipToEndOfBlockData();
  274.       this.setBlockData(var6);
  275.       if (var1 == null) {
  276.          throw new ClassNotFoundException(var5.getName());
  277.       } else {
  278.          var5.setClass(var1);
  279.          ObjectStreamClass var7 = (ObjectStreamClass)this.readObject();
  280.          var5.setSuperclass(var7);
  281.          return var5;
  282.       }
  283.    }
  284.  
  285.    private Object inputArray() throws IOException, ClassNotFoundException {
  286.       ObjectStreamClass var1 = (ObjectStreamClass)this.readObject();
  287.       Class var2 = var1.forClass();
  288.       int var3 = this.readInt();
  289.       this.currentObject = allocateNewArray(var2, var3);
  290.       this.assignWireOffset(this.currentObject);
  291.       Class var5 = var2.getComponentType();
  292.       if (var5.isPrimitive()) {
  293.          if (this.buffer == null) {
  294.             this.buffer = new byte[1024];
  295.          }
  296.  
  297.          int var6 = this.buffer.length;
  298.          int var7 = this.buffer.length;
  299.          if (var5 == Boolean.TYPE) {
  300.             boolean[] var8 = (boolean[])this.currentObject;
  301.  
  302.             for(int var4 = 0; var4 < var3; ++var4) {
  303.                if (var6 >= var7) {
  304.                   int var9 = Math.min(var3 - var4, var7);
  305.                   this.readFully(this.buffer, 0, var9);
  306.                   var6 = 0;
  307.                }
  308.  
  309.                var8[var4] = this.buffer[var6] != 0;
  310.                ++var6;
  311.             }
  312.          } else if (var5 == Byte.TYPE) {
  313.             byte[] var19 = (byte[])this.currentObject;
  314.             this.readFully(var19, 0, var3);
  315.          } else if (var5 == Short.TYPE) {
  316.             short[] var20 = (short[])this.currentObject;
  317.  
  318.             for(int var11 = 0; var11 < var3; ++var11) {
  319.                if (var6 > var7 - 2) {
  320.                   int var26 = Math.min((var3 - var11) * 2, var7);
  321.                   this.readFully(this.buffer, 0, var26);
  322.                   var6 = 0;
  323.                }
  324.  
  325.                var20[var11] = (short)(((this.buffer[var6] & 255) << 8) + (this.buffer[var6 + 1] & 255));
  326.                var6 += 2;
  327.             }
  328.          } else if (var5 == Integer.TYPE) {
  329.             int[] var21 = (int[])this.currentObject;
  330.  
  331.             for(int var12 = 0; var12 < var3; ++var12) {
  332.                if (var6 > var7 - 4) {
  333.                   int var27 = Math.min((var3 - var12) * 4, var7);
  334.                   this.readFully(this.buffer, 0, var27);
  335.                   var6 = 0;
  336.                }
  337.  
  338.                var21[var12] = ((this.buffer[var6] & 255) << 24) + ((this.buffer[var6 + 1] & 255) << 16) + ((this.buffer[var6 + 2] & 255) << 8) + (this.buffer[var6 + 3] & 255);
  339.                var6 += 4;
  340.             }
  341.          } else if (var5 == Long.TYPE) {
  342.             long[] var22 = (long[])this.currentObject;
  343.  
  344.             for(int var13 = 0; var13 < var3; ++var13) {
  345.                if (var6 > var7 - 8) {
  346.                   int var28 = Math.min((var3 - var13) * 8, var7);
  347.                   this.readFully(this.buffer, 0, var28);
  348.                   var6 = 0;
  349.                }
  350.  
  351.                int var29 = ((this.buffer[var6] & 255) << 24) + ((this.buffer[var6 + 1] & 255) << 16) + ((this.buffer[var6 + 2] & 255) << 8) + (this.buffer[var6 + 3] & 255);
  352.                int var10 = ((this.buffer[var6 + 4] & 255) << 24) + ((this.buffer[var6 + 5] & 255) << 16) + ((this.buffer[var6 + 6] & 255) << 8) + (this.buffer[var6 + 7] & 255);
  353.                var22[var13] = ((long)var29 << 32) + ((long)var10 & 4294967295L);
  354.                var6 += 8;
  355.             }
  356.          } else if (var5 == Float.TYPE) {
  357.             float[] var23 = (float[])this.currentObject;
  358.  
  359.             for(int var14 = 0; var14 < var3; ++var14) {
  360.                if (var6 > var7 - 4) {
  361.                   int var30 = Math.min((var3 - var14) * 4, var7);
  362.                   this.readFully(this.buffer, 0, var30);
  363.                   var6 = 0;
  364.                }
  365.  
  366.                int var31 = ((this.buffer[var6] & 255) << 24) + ((this.buffer[var6 + 1] & 255) << 16) + ((this.buffer[var6 + 2] & 255) << 8) + (this.buffer[var6 + 3] & 255);
  367.                var6 += 4;
  368.                var23[var14] = Float.intBitsToFloat(var31);
  369.             }
  370.          } else if (var5 == Double.TYPE) {
  371.             double[] var24 = (double[])this.currentObject;
  372.  
  373.             for(int var15 = 0; var15 < var3; ++var15) {
  374.                if (var6 > var7 - 8) {
  375.                   int var32 = Math.min((var3 - var15) * 8, var7);
  376.                   this.readFully(this.buffer, 0, var32);
  377.                   var6 = 0;
  378.                }
  379.  
  380.                int var33 = ((this.buffer[var6] & 255) << 24) + ((this.buffer[var6 + 1] & 255) << 16) + ((this.buffer[var6 + 2] & 255) << 8) + (this.buffer[var6 + 3] & 255);
  381.                int var35 = ((this.buffer[var6 + 4] & 255) << 24) + ((this.buffer[var6 + 5] & 255) << 16) + ((this.buffer[var6 + 6] & 255) << 8) + (this.buffer[var6 + 7] & 255);
  382.                var6 += 8;
  383.                var24[var15] = Double.longBitsToDouble(((long)var33 << 32) + ((long)var35 & 4294967295L));
  384.             }
  385.          } else {
  386.             if (var5 != Character.TYPE) {
  387.                throw new InvalidClassException(var2.getName());
  388.             }
  389.  
  390.             char[] var25 = (char[])this.currentObject;
  391.  
  392.             for(int var16 = 0; var16 < var3; ++var16) {
  393.                if (var6 > var7 - 2) {
  394.                   int var34 = Math.min((var3 - var16) * 2, var7);
  395.                   this.readFully(this.buffer, 0, var34);
  396.                   var6 = 0;
  397.                }
  398.  
  399.                var25[var16] = (char)(((this.buffer[var6] & 255) << 8) + (this.buffer[var6 + 1] & 255));
  400.                var6 += 2;
  401.             }
  402.          }
  403.       } else {
  404.          Object[] var18 = this.currentObject;
  405.  
  406.          for(int var17 = 0; var17 < var3; ++var17) {
  407.             var18[var17] = this.readObject();
  408.          }
  409.       }
  410.  
  411.       return this.currentObject;
  412.    }
  413.  
  414.    private int inputObject() throws IOException, ClassNotFoundException {
  415.       int var1 = -1;
  416.       this.currentClassDesc = (ObjectStreamClass)this.readObject();
  417.       this.currentClass = this.currentClassDesc.forClass();
  418.       if (this.currentClassDesc.isExternalizable()) {
  419.          try {
  420.             this.currentObject = allocateNewObject(this.currentClass, this.currentClass);
  421.             var1 = this.assignWireOffset(this.currentObject);
  422.             Externalizable var2 = (Externalizable)this.currentObject;
  423.             var2.readExternal(this);
  424.          } catch (IllegalAccessException var19) {
  425.             throw new InvalidClassException(this.currentClass.getName(), "IllegalAccessException");
  426.          } catch (InstantiationException var20) {
  427.             throw new InvalidClassException(this.currentClass.getName(), "InstantiationException");
  428.          }
  429.       } else {
  430.          ObjectStreamClass var23 = this.currentClassDesc;
  431.          Class var3 = this.currentClass;
  432.          int var4 = this.spClass;
  433.          var23 = this.currentClassDesc;
  434.  
  435.          for(var3 = this.currentClass; var23 != null; var23 = var23.getSuperclass()) {
  436.             Class var5 = var23.forClass();
  437.  
  438.             Class var6;
  439.             for(var6 = var3; var6 != null && var5 != var6; var6 = var6.getSuperclass()) {
  440.             }
  441.  
  442.             ++this.spClass;
  443.             if (this.spClass >= this.classes.length) {
  444.                int var7 = this.classes.length * 2;
  445.                Class[] var8 = new Class[var7];
  446.                ObjectStreamClass[] var9 = new ObjectStreamClass[var7];
  447.                System.arraycopy(this.classes, 0, var8, 0, this.classes.length);
  448.                System.arraycopy(this.classdesc, 0, var9, 0, this.classes.length);
  449.                this.classes = var8;
  450.                this.classdesc = var9;
  451.             }
  452.  
  453.             if (var6 == null) {
  454.                this.classdesc[this.spClass] = var23;
  455.                this.classes[this.spClass] = null;
  456.             } else {
  457.                this.classdesc[this.spClass] = var23;
  458.                this.classes[this.spClass] = var6;
  459.                var3 = var6.getSuperclass();
  460.             }
  461.          }
  462.  
  463.          try {
  464.             this.currentObject = allocateNewObject(this.currentClass, var3);
  465.          } catch (NoSuchMethodError var16) {
  466.             throw new InvalidClassException(var3.getName(), "NoSuchMethodError");
  467.          } catch (IllegalAccessException var17) {
  468.             throw new InvalidClassException(var3.getName(), "IllegalAccessException");
  469.          } catch (InstantiationException var18) {
  470.             throw new InvalidClassException(var3.getName(), "InstantiationException");
  471.          }
  472.  
  473.          var1 = this.assignWireOffset(this.currentObject);
  474.  
  475.          try {
  476.             for(this.spClass = this.spClass; this.spClass > var4; --this.spClass) {
  477.                this.currentClassDesc = this.classdesc[this.spClass];
  478.                this.currentClass = this.classes[this.spClass];
  479.                if (this.classes[this.spClass] != null) {
  480.                   this.setBlockData(true);
  481.                   this.currentClassDesc.localClassDescriptor();
  482.                   if (!this.invokeObjectReader(this.currentObject, this.currentClass)) {
  483.                      this.defaultReadObject();
  484.                   }
  485.                } else if (this.currentClassDesc.getFieldSequence() != null) {
  486.                   boolean var26 = this.setBlockData(false);
  487.                   this.inputClassFields((Object)null, this.currentClass, this.currentClassDesc.getFieldSequence());
  488.                   this.setBlockData(var26);
  489.                }
  490.  
  491.                if (this.currentClassDesc.hasWriteObject()) {
  492.                   this.SkipToEndOfBlockData();
  493.                }
  494.  
  495.                this.setBlockData(false);
  496.             }
  497.          } finally {
  498.             this.spClass = var4;
  499.          }
  500.       }
  501.  
  502.       return var1;
  503.    }
  504.  
  505.    private void SkipToEndOfBlockData() throws IOException, ClassNotFoundException {
  506.       while(this.peekCode() != 120) {
  507.          try {
  508.             this.readObject();
  509.          } catch (OptionalDataException var2) {
  510.             if (var2.length > 0) {
  511.                ((InputStream)this).skip((long)var2.length);
  512.             }
  513.          }
  514.       }
  515.  
  516.       this.readCode();
  517.    }
  518.  
  519.    private void resetStream() throws IOException {
  520.       this.wireHandle2Object = new Vector(100, 100);
  521.       this.nextWireOffset = 0;
  522.       this.classes = new Class[20];
  523.       this.classdesc = new ObjectStreamClass[20];
  524.       this.spClass = 0;
  525.       this.setBlockData(true);
  526.       this.callbacks = null;
  527.    }
  528.  
  529.    private int assignWireOffset(Object var1) throws IOException {
  530.       this.wireHandle2Object.addElement(var1);
  531.       if (++this.nextWireOffset != this.wireHandle2Object.size()) {
  532.          throw new StreamCorruptedException("Elements not assigned in order");
  533.       } else {
  534.          return this.nextWireOffset - 1;
  535.       }
  536.    }
  537.  
  538.    private byte peekCode() throws IOException, StreamCorruptedException {
  539.       while(this.currCode == 0) {
  540.          int var1 = this.field_0.read();
  541.          if (var1 < 0) {
  542.             throw new EOFException("Expecting code");
  543.          }
  544.  
  545.          this.currCode = (byte)var1;
  546.          if (this.currCode >= 112 && this.currCode <= 123) {
  547.             if (this.currCode != 121) {
  548.                continue;
  549.             }
  550.  
  551.             if (this.recursionDepth == 0 && this.currentObject == null && this.currentClassDesc == null) {
  552.                this.resetStream();
  553.                this.currCode = 0;
  554.                continue;
  555.             }
  556.  
  557.             throw new StreamCorruptedException("Illegal stream state for reset");
  558.          }
  559.  
  560.          throw new StreamCorruptedException("Type code out of range, is " + this.currCode);
  561.       }
  562.  
  563.       return this.currCode;
  564.    }
  565.  
  566.    private byte readCode() throws IOException, StreamCorruptedException {
  567.       byte var1 = this.peekCode();
  568.       this.currCode = 0;
  569.       return var1;
  570.    }
  571.  
  572.    private void pushbackCode(byte var1) {
  573.       this.currCode = var1;
  574.    }
  575.  
  576.    private boolean setBlockData(boolean var1) throws IOException {
  577.       if (this.blockDataMode == var1) {
  578.          return var1;
  579.       } else if (this.blockDataMode && this.count > 0) {
  580.          throw new StreamCorruptedException("Unread data");
  581.       } else {
  582.          this.count = var1 ? 0 : -1;
  583.          this.blockDataMode = var1;
  584.          return !var1;
  585.       }
  586.    }
  587.  
  588.    public int read() throws IOException {
  589.       int var1;
  590.       if (!this.blockDataMode) {
  591.          var1 = this.field_0.read();
  592.       } else {
  593.          while(this.count == 0) {
  594.             this.refill();
  595.          }
  596.  
  597.          if (this.count < 0) {
  598.             return -1;
  599.          }
  600.  
  601.          var1 = this.field_0.read();
  602.          if (var1 >= 0) {
  603.             --this.count;
  604.          }
  605.       }
  606.  
  607.       return var1;
  608.    }
  609.  
  610.    private void refill() throws IOException {
  611.       this.count = -1;
  612.  
  613.       byte var1;
  614.       try {
  615.          var1 = this.peekCode();
  616.       } catch (EOFException var7) {
  617.          return;
  618.       }
  619.  
  620.       if (var1 == 119) {
  621.          var1 = this.readCode();
  622.          int var10 = this.field_0.read();
  623.          if (var10 < 0) {
  624.             throw new StreamCorruptedException("EOF expecting count");
  625.          } else {
  626.             this.count = var10 & 255;
  627.          }
  628.       } else {
  629.          if (var1 == 122) {
  630.             var1 = this.readCode();
  631.             int var2 = this.field_0.read();
  632.             int var3 = this.field_0.read();
  633.             int var4 = this.field_0.read();
  634.             int var5 = this.field_0.read();
  635.             if ((var2 | var3 | var4 | var5) < 0) {
  636.                throw new StreamCorruptedException("EOF expecting count");
  637.             }
  638.  
  639.             int var6 = var2 << 24 | var3 << 16 | var4 << 8 | var5;
  640.             if (var6 < 0) {
  641.                throw new StreamCorruptedException("Negative block data size");
  642.             }
  643.  
  644.             this.count = var6;
  645.          }
  646.  
  647.       }
  648.    }
  649.  
  650.    public int read(byte[] var1, int var2, int var3) throws IOException {
  651.       if (var3 < 0) {
  652.          throw new IndexOutOfBoundsException();
  653.       } else if (!this.blockDataMode) {
  654.          return this.field_0.read(var1, var2, var3);
  655.       } else {
  656.          while(this.count == 0) {
  657.             this.refill();
  658.          }
  659.  
  660.          if (this.count < 0) {
  661.             return -1;
  662.          } else {
  663.             int var5 = Math.min(var3, this.count);
  664.             int var4 = this.field_0.read(var1, var2, var5);
  665.             if (var4 > 0) {
  666.                this.count -= var4;
  667.             }
  668.  
  669.             return var4;
  670.          }
  671.       }
  672.    }
  673.  
  674.    public int available() throws IOException {
  675.       if (this.blockDataMode) {
  676.          if (this.count == 0 && this.field_0.available() > 0) {
  677.             this.refill();
  678.          }
  679.  
  680.          return this.count >= 0 ? this.count : 0;
  681.       } else {
  682.          return 0;
  683.       }
  684.    }
  685.  
  686.    public void close() throws IOException {
  687.       this.field_0.close();
  688.    }
  689.  
  690.    public boolean readBoolean() throws IOException {
  691.       return this.dis.readBoolean();
  692.    }
  693.  
  694.    public byte readByte() throws IOException {
  695.       return this.dis.readByte();
  696.    }
  697.  
  698.    public int readUnsignedByte() throws IOException {
  699.       return this.dis.readUnsignedByte();
  700.    }
  701.  
  702.    public short readShort() throws IOException {
  703.       return this.dis.readShort();
  704.    }
  705.  
  706.    public int readUnsignedShort() throws IOException {
  707.       return this.dis.readUnsignedShort();
  708.    }
  709.  
  710.    public char readChar() throws IOException {
  711.       return this.dis.readChar();
  712.    }
  713.  
  714.    public int readInt() throws IOException {
  715.       return this.dis.readInt();
  716.    }
  717.  
  718.    public long readLong() throws IOException {
  719.       return this.dis.readLong();
  720.    }
  721.  
  722.    public float readFloat() throws IOException {
  723.       return this.dis.readFloat();
  724.    }
  725.  
  726.    public double readDouble() throws IOException {
  727.       return this.dis.readDouble();
  728.    }
  729.  
  730.    public void readFully(byte[] var1) throws IOException {
  731.       this.dis.readFully(var1);
  732.    }
  733.  
  734.    public void readFully(byte[] var1, int var2, int var3) throws IOException {
  735.       if (var3 < 0) {
  736.          throw new IndexOutOfBoundsException();
  737.       } else {
  738.          this.dis.readFully(var1, var2, var3);
  739.       }
  740.    }
  741.  
  742.    public int skipBytes(int var1) throws IOException {
  743.       return this.dis.skipBytes(var1);
  744.    }
  745.  
  746.    public String readLine() throws IOException {
  747.       return this.dis.readLine();
  748.    }
  749.  
  750.    public String readUTF() throws IOException {
  751.       return this.dis.readUTF();
  752.    }
  753.  
  754.    private native void inputClassFields(Object var1, Class var2, int[] var3) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException;
  755.  
  756.    private static native Object allocateNewObject(Class var0, Class var1) throws InstantiationException, IllegalAccessException;
  757.  
  758.    private static native Object allocateNewArray(Class var0, int var1);
  759.  
  760.    private native boolean invokeObjectReader(Object var1, Class var2) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException;
  761. }
  762.